package com.wf.demo.info.util;

import com.wf.demo.info.pojo.Parse;

import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

public class ParseUtil {
    /**
     * 16进制的字符串转换成10进制字符串
     * The conversion of 16 to ASCII
     *
     * @param hex
     * @return
     * @other > Integer.toHexString(int) -> 10 to 16
     */
    public static String convertHexToString(String hex) {

        StringBuilder sb = new StringBuilder();   //char字符串
        StringBuilder temp = new StringBuilder();   //数字字符串

        // 564e3a322d302e312e34 split into two characters 56, 4e, 3a...
        for (int i = 0; i < hex.length() - 1; i += 2) {

            // grab the hex in pairs
            String output = hex.substring(i, (i + 2));
            // convert hex to decimal
            int decimal = Integer.parseInt(output, 16);
            // convert the decimal to character
            sb.append((char) decimal);

            temp.append(decimal);
        }
        // System.out.println(sb.toString());
        return sb.toString();
    }
    /**
     * 16进制的字符串转换成float
     *
     */
    public static Float HexToFloat(String hex) {
        //将16进制字符串解析成float型数字
        Float value = Float.intBitsToFloat(Integer.valueOf(hex.trim(), 16));
        System.out.println(value);
        return  value;
    }
    /**
     * 2  5
     * 19 23
     * */
    public static Float intArrayToFloat(int[] dataArray,int byteStart,int byteEnd)  {
        //将int数组解析成float型数字
        StringBuilder sb=new StringBuilder();
        //A4是第19个字节，数据起始位置就是第20个字节，data[19]
        byteStart=byteStart+17;
        byteEnd=byteEnd+17;
        for(int i=byteStart;i<=byteEnd;i++){
            String hex =String.format("%02x", dataArray[i]);//2表示需要两个16进行数
            sb.append(hex);
        }
        String s= sb.toString(); //还原成十六进制
        Long longData=Long.parseLong(s.trim(),16);
        //System.out.println(longData);
        Float value1=Float.intBitsToFloat(longData.intValue());
        // System.out.println(value1);
        return  value1;
    }
    /**
     *功能描述
     * @author wf
     * @date 2019/11/26
     * @param intData
     * @param parse
     * @return java.math.BigDecimal
     */
    public static BigDecimal getValueByParse(int[] intData, Parse parse){
        int byteStart = parse.getByteStart();
        int byteEnd   = parse.getByteEnd();
        BigDecimal outValue=new BigDecimal(-999); //初始值为-999,初始值未变时，表示数据解析错误
        String parseRule  =parse.getParseRule();
        System.out.println("byteStart="+byteStart+",byteEnd="+byteEnd+",parseRule="+parseRule);

        try{ //如果数据类型是unsigned short /16位
            if(parseRule.equals("unsignedShort")){
                int dataValue= intData[byteStart+17]* 256+intData[byteEnd+17];
                System.out.println("解析得到的数值是"+dataValue);
                outValue = new BigDecimal(Integer.toString(dataValue));//把数值转换为BigDecimal输出
            }
            //如果数据类型是unsigned int /32位
            else  if(parseRule.equals("unsignedInt")){
                int dataValue= intData[byteStart+17]* 256*256*256+intData[byteStart+18]*256*256+
                        intData[byteStart+19]* 256+intData[byteEnd+17];
                System.out.println("解析得到的数值是"+dataValue);
                outValue= new BigDecimal(Integer.toString(dataValue));//把数值转换为BigDecimal
            }
            //如果数据类型是float /32位
            else  if (parseRule.equals("float")){
                //解析得到数值
                Float dataValue = ParseUtil.intArrayToFloat(intData,byteStart,byteEnd);
                System.out.println("解析得到的数值是"+dataValue);
                outValue= new BigDecimal(Float.toString(dataValue));//把数值转换为BigDecimal
            }

        }catch (Exception e){
            System.out.println("解析错误，北斗传输过来的数据不完整，没有parse表规定的数据");
            e.printStackTrace();
        }
        finally {
            return  outValue;
        }
    }
    /**
     * 检查年月日是否合法
     * @param ymd
     * @return
     */
    public static boolean checkYearMonthDay(String ymd) {
        if (ymd == null || ymd.length() == 0) {
            return false;
        }
        String s = ymd.replaceAll("[/\\- ]", "");
        SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
        try {
            Date date = format.parse(s);
            if (!format.format(date).equals(s)) {
                return false;
            }
        } catch (ParseException e) {
            return false;
        }
        return true;
    }
    public static LocalDate stirng2LocalDate(String ymd) throws ParseException {
        String s = ymd.replaceAll("[/\\- ]", "");
        SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
        Date date = format.parse(s);
        LocalDate localDate=LocalDateTimeUtils.date2LocalDate(date);
        return  localDate;
    }

    public static float floatSave2Decimal(float f){
        // 设置位数
        int scale = 4;
        // 表示四舍五入，可以选择其他舍值方式，例如去尾，等等.
        int roundingMode = 4;
        BigDecimal bd = new BigDecimal((float) f);
        bd = bd.setScale(scale, roundingMode);
        f = bd.floatValue();
        System.out.println(f);
        return f;
    }
    public static <K, V> Map.Entry<K, V> getHead(LinkedHashMap<K, V> map) {
        return map.entrySet().iterator().next();
    }

    public static <K, V> Map.Entry<K, V> getTail(LinkedHashMap<K, V> map) {
        Iterator<Map.Entry<K, V>> iterator = map.entrySet().iterator();
        Map.Entry<K, V> tail = null;
        while (iterator.hasNext()) {
            tail = iterator.next();
        }
        return tail;
    }
    /**
     *功能描述  异或运算常用来做数据的简单校验。Java的实现：（将字节数组两两异或，返回最后异或值） 如果是校验则看异或结果是否为0即可
     * @author wf
     * @date 2020/5/31
     * @param datas
     * @return byte
     */

    public static byte getXor(byte[] datas){

        byte temp=datas[0];

        for (int i = 1; i <datas.length; i++) {
            temp ^=datas[i];
        }

        return temp;
    }
    /**
     *  byte数组转16进制字符串
     * @param b
     * @return
     */
    public  static  String printHexString(byte[] b) {
        StringBuffer sbf = new StringBuffer();
        for (int i = 0; i < b.length; i++) {
            String hex = Integer.toHexString(b[i] & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            sbf.append(hex.toUpperCase() + "  ");
        }
        return sbf.toString().trim();
    }


}



